package patterns.creational.factory;

/**
 * 工厂方法模式示例
 * 定义一个用于创建对象的接口，让子类决定实例化哪一个类
 */
public class FactoryMethodPattern {

    public static void main(String[] args) {
        // 使用简单工厂
        System.out.println("===== 简单工厂模式 =====");
        Product productA = SimpleFactory.createProduct("A");
        productA.use();
        
        Product productB = SimpleFactory.createProduct("B");
        productB.use();
        
        // 使用工厂方法
        System.out.println("\n===== 工厂方法模式 =====");
        Factory factoryA = new ConcreteFactoryA();
        Product productFromFactoryA = factoryA.createProduct();
        productFromFactoryA.use();
        
        Factory factoryB = new ConcreteFactoryB();
        Product productFromFactoryB = factoryB.createProduct();
        productFromFactoryB.use();
    }
}

/**
 * 产品接口
 */
interface Product {
    void use();
}

/**
 * 具体产品A
 */
class ConcreteProductA implements Product {
    @Override
    public void use() {
        System.out.println("使用产品A");
    }
}

/**
 * 具体产品B
 */
class ConcreteProductB implements Product {
    @Override
    public void use() {
        System.out.println("使用产品B");
    }
}

/**
 * 简单工厂
 * 不属于GoF的23种设计模式，但常作为工厂方法的入门
 */
class SimpleFactory {
    public static Product createProduct(String type) {
        if ("A".equals(type)) {
            return new ConcreteProductA();
        } else if ("B".equals(type)) {
            return new ConcreteProductB();
        }
        throw new IllegalArgumentException("未知产品类型: " + type);
    }
}

/**
 * 工厂接口
 */
interface Factory {
    Product createProduct();
}

/**
 * 具体工厂A，专门用于创建产品A
 */
class ConcreteFactoryA implements Factory {
    @Override
    public Product createProduct() {
        return new ConcreteProductA();
    }
}

/**
 * 具体工厂B，专门用于创建产品B
 */
class ConcreteFactoryB implements Factory {
    @Override
    public Product createProduct() {
        return new ConcreteProductB();
    }
} 